home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CUCD / Programming / OUI / rcs / screen.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  13.0 KB  |  534 lines

  1. head    1.2;
  2. access;
  3. symbols;
  4. locks
  5.     dlorre:1.2; strict;
  6. comment    @// @;
  7.  
  8.  
  9. 1.2
  10. date    97.07.14.04.20.02;    author dlorre;    state Exp;
  11. branches;
  12. next    1.1;
  13.  
  14. 1.1
  15. date    96.08.22.02.05.10;    author dlorre;    state Exp;
  16. branches;
  17. next    ;
  18.  
  19.  
  20. desc
  21. @Oui.lib -- Object User Interface
  22. Projet créé en 1994
  23. Auteur: Dominique Lorre
  24. @
  25.  
  26.  
  27. 1.2
  28. log
  29. @*** empty log message ***
  30. @
  31. text
  32. @// $Id$
  33. #include <exec/types.h>
  34. #include <graphics/gfxbase.h>
  35. #include <intuition/intuitionbase.h>
  36. #include <intuition/screens.h>
  37. #include <clib/macros.h>
  38. #include <mydebug.h>
  39.  
  40. #include "screen.h"
  41.  
  42. #include <proto/graphics.h>
  43. #include <proto/intuition.h>
  44. #include <proto/gadtools.h>
  45.  
  46. #include <stdio.h>
  47.  
  48. const UWORD NOMATCH = 0xFFFF ;
  49.  
  50. screen::screen(UWORD *xp, STRPTR name)
  51. {
  52.     status = FALSE ;
  53.     owner = FALSE ;
  54.     xpens = new UWORD[NUM_XPENS] ;
  55.     if (xpens) {
  56.         if (xp) {
  57.             defpens = NULL ;
  58.             setxpens(xp) ;
  59.         }
  60.         else {
  61.             defpens = new UWORD[NUM_XPENS] ;
  62.         }
  63.         if (xp || defpens) {
  64.             scr = LockPubScreen((UBYTE *)name) ;
  65.             if (!scr)
  66.                 scr = LockPubScreen(NULL) ;
  67.             if (scr)
  68.                 init() ;
  69.         }
  70.     }
  71. }
  72.  
  73. screen::screen(UWORD *xp, ULONG tdata, ...)
  74. {
  75. TagItem *tags = (TagItem *)&tdata ;
  76.     status = FALSE ;
  77.     owner = TRUE ;
  78.     xpens = new UWORD[NUM_XPENS] ;
  79.     if (xpens) {
  80.         if (xp) {
  81.             defpens = NULL ;
  82.             setxpens(xp) ;
  83.         }
  84.         else
  85.             defpens = new UWORD[NUM_XPENS] ;
  86.         if (xp || defpens) {
  87.             scr = OpenScreenTags(NULL,
  88.                 SA_ErrorCode,   &error,
  89.                 TAG_MORE,       tags) ;
  90.  
  91.             if (scr)
  92.                 init() ;
  93.         }
  94.     }
  95. }
  96.  
  97. screen::screen(UWORD *xp, TagItem *tags)
  98. {
  99.     status = FALSE ;
  100.     owner = TRUE ;
  101.     xpens = new UWORD[NUM_XPENS] ;
  102.     if (xpens) {
  103.         if (xp) {
  104.             defpens = NULL ;
  105.             setxpens(xp) ;
  106.         }
  107.         else
  108.             defpens = new UWORD[NUM_XPENS] ;
  109.         if (xp || defpens) {
  110.             scr = OpenScreenTags(NULL,
  111.                 SA_ErrorCode,   &error,
  112.                 TAG_MORE,       tags) ;
  113.  
  114.             if (scr)
  115.                 init() ;
  116.         }
  117.     }
  118. }
  119.  
  120. void screen::init()
  121. {
  122.  
  123.     vi = GetVisualInfo(scr, TAG_DONE);
  124.     if (vi) {
  125.         font = OpenFont(scr->Font) ;
  126.         if (font) {
  127.             drawinfo = GetScreenDrawInfo(scr) ;
  128.             if (drawinfo) {
  129.                 rp = &scr->RastPort ;
  130.                 getsize() ;
  131.                 if (defpens) {
  132.                     setdefpens() ;
  133.                 }
  134.                 status = TRUE ;
  135.             }
  136.             else
  137.                 error = -3 ;
  138.         }
  139.         else
  140.             error = -2 ;
  141.     }
  142.     else
  143.         error = -1 ;
  144. }
  145.  
  146. screen::~screen()
  147. {
  148.     if (xpens)
  149.         delete xpens ;
  150.  
  151.     if (defpens) {
  152.         if (GfxBase->LibNode.lib_Version >=39) {
  153.             ColorMap *cm = scr->ViewPort.ColorMap ;
  154.             ReleasePen(cm, defpens[GREEN_PEN]) ;
  155.             ReleasePen(cm, defpens[RED_PEN]) ;
  156.             ReleasePen(cm, defpens[WHITE_PEN]) ;
  157.             ReleasePen(cm, defpens[BLACK_PEN]) ;
  158.         }
  159.         delete defpens ;
  160.     }
  161.     if (drawinfo)
  162.         FreeScreenDrawInfo(scr, drawinfo) ;
  163.     if (font)
  164.         CloseFont(font) ;
  165.     if (vi)
  166.         FreeVisualInfo(vi) ;
  167.     if (scr) {
  168.         if (owner)
  169.             CloseScreen(scr) ;
  170.         else {
  171.             UnlockPubScreen(NULL, scr) ;
  172.         }
  173.     }
  174. }
  175.  
  176.  
  177. void screen::getsize()
  178. {
  179. DisplayInfo displayinfo ;
  180. DisplayInfoHandle handle ;
  181. ULONG   modeid ;
  182.  
  183.     left = short(MAX(0, -scr->LeftEdge)) ;
  184.     top = short(MAX(0, -scr->TopEdge) + scr->BarHeight + 1) ;
  185.     height = short(scr->Height - scr->BarHeight) ;
  186.     width = scr->Width ;
  187.     winbarheight = short(scr->WBorTop + font->tf_YSize + 1) ;
  188.     xratio = yratio = 1 ;
  189.     modeid = GetVPModeID(&scr->ViewPort);
  190.  
  191.     if ((modeid != INVALID_ID) && (handle = FindDisplayInfo(modeid))) {
  192.         if (GetDisplayInfoData(handle, (UBYTE *)&displayinfo, sizeof(DisplayInfo),
  193.             DTAG_DISP, NULL) && displayinfo.PixelSpeed) {
  194.             /* This two lines are code from Ghostscript amiga device */
  195.                 xratio = (35*140) / displayinfo.PixelSpeed ;
  196.                 yratio = (xratio * displayinfo.Resolution.x) / displayinfo.Resolution.y ;
  197.         }
  198.     }
  199. }
  200.  
  201.  
  202. void screen::front()
  203. {
  204.     ScreenToFront(scr) ;
  205. }
  206.  
  207. void screen::back()
  208. {
  209.     ScreenToBack(scr) ;
  210. }
  211.  
  212. void screen::cfront()
  213. {
  214.     if (IntuitionBase->LibNode.lib_Version >= 39)
  215.         ScreenDepth(scr, SDEPTH_TOFRONT | SDEPTH_INFAMILY, NULL) ;
  216.     else
  217.         ScreenToFront(scr) ;
  218. }
  219.  
  220. void screen::cback()
  221. {
  222.     if (IntuitionBase->LibNode.lib_Version >= 39)
  223.         ScreenDepth(scr, SDEPTH_TOBACK | SDEPTH_INFAMILY, NULL) ;
  224.     else
  225.         ScreenToBack(scr) ;
  226. }
  227.  
  228.  
  229. void screen::beep()
  230. {
  231.     DisplayBeep(scr) ;
  232. }
  233.  
  234. void screen::setxpens(UWORD *p)
  235. {
  236. int i = 0 ;
  237.  
  238.     while (p[i] != 0xFFFF) {
  239.         xpens[i] = p[i++]  ;
  240.     }
  241. }
  242.  
  243. void screen::setdefpens()
  244. {
  245. int i ;
  246. ColorMap *cm = scr->ViewPort.ColorMap ;
  247.  
  248.     if (GfxBase->LibNode.lib_Version >= 39) {
  249.  
  250.         defpens[GREEN_PEN] = ObtainBestPen(cm,
  251.             0x00000000,
  252.             0xffffffff,
  253.             0x00000000,
  254.             OBP_Precision,  PRECISION_IMAGE,
  255.             OBP_FailIfBad,  TRUE,
  256.             TAG_DONE) ;
  257.  
  258.         defpens[RED_PEN] = ObtainBestPen(cm,
  259.             0xffffffff,
  260.             0x00000000,
  261.             0x00000000,
  262.             OBP_Precision,  PRECISION_IMAGE,
  263.             OBP_FailIfBad,  TRUE,
  264.             TAG_DONE) ;
  265.  
  266.         defpens[WHITE_PEN] = ObtainBestPen(cm,
  267.             0xffffffff,
  268.             0xffffffff,
  269.             0xffffffff,
  270.             OBP_Precision,  PRECISION_IMAGE,
  271.             OBP_FailIfBad,  TRUE,
  272.             TAG_DONE) ;
  273.  
  274.         defpens[BLACK_PEN] = ObtainBestPen(cm,
  275.             0x00000000,
  276.             0x00000000,
  277.             0x00000000,
  278.             OBP_Precision,  PRECISION_IMAGE,
  279.             OBP_FailIfBad,  TRUE,
  280.             TAG_DONE) ;
  281.  
  282.     }
  283.     else {
  284.         defpens[GREEN_PEN] = drawinfo->dri_Pens[HIGHLIGHTTEXTPEN] ;
  285.         defpens[RED_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  286.         defpens[WHITE_PEN] = drawinfo->dri_Pens[HIGHLIGHTTEXTPEN] ;
  287.         defpens[BLACK_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  288.     }
  289.     defpens[GFILL_PEN] = drawinfo->dri_Pens[BACKGROUNDPEN] ;
  290.     defpens[GBORDER_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  291.     defpens[BUTTONFILL_PEN] = drawinfo->dri_Pens[BACKGROUNDPEN] ;
  292.     if (GfxBase->LibNode.lib_Version >= 39) {
  293.         xpens[GREEN_PEN] =
  294.             (defpens[GREEN_PEN] != NOMATCH) ? defpens[GREEN_PEN] :
  295.             FindColor(cm,
  296.                 0x00000000,
  297.                 0xffffffff,
  298.                 0x00000000,
  299.                 -1) ;
  300.  
  301.         xpens[RED_PEN] =
  302.             (defpens[RED_PEN] != NOMATCH) ? defpens[RED_PEN] :
  303.             FindColor(cm,
  304.                 0xffffffff,
  305.                 0x00000000,
  306.                 0x00000000,
  307.                 -1) ;
  308.         xpens[WHITE_PEN] =
  309.             (defpens[WHITE_PEN] != NOMATCH) ? defpens[WHITE_PEN] :
  310.             FindColor(cm,
  311.                 0xffffffff,
  312.                 0xffffffff,
  313.                 0xffffffff,
  314.                 -1) ;
  315.         xpens[BLACK_PEN] =
  316.             (defpens[BLACK_PEN] != NOMATCH) ? defpens[BLACK_PEN] :
  317.             FindColor(cm,
  318.                 0x00000000,
  319.                 0x00000000,
  320.                 0x00000000,
  321.                 -1) ;
  322.  
  323.         if (xpens[WHITE_PEN] == 0) xpens[WHITE_PEN] = (drawinfo->dri_Depth > 1)?2:1 ;
  324.         if (xpens[BLACK_PEN] == 0) xpens[BLACK_PEN] = 1 ;
  325.         if (xpens[BLACK_PEN] >0x0F &&
  326.             IntuitionBase->LibNode.lib_Version == 39)
  327.                 xpens[BLACK_PEN] = 1 ;
  328.         if (xpens[GREEN_PEN] == 0) xpens[GREEN_PEN] = (drawinfo->dri_Depth > 1)?2:1 ;
  329.         if (xpens[RED_PEN] == 0) xpens[RED_PEN] = 1 ;
  330.         i = 4 ;
  331.     }
  332.     else
  333.         i = 0 ;
  334.     while (i < NUM_XPENS)
  335.         xpens[i] = defpens[i++] ;
  336. }@
  337.  
  338.  
  339. 1.1
  340. log
  341. @Initial revision
  342. @
  343. text
  344. @d1 1
  345. d6 2
  346. a7 2
  347. #include <cclib/macros.h>
  348. #include <cclib/debug_protos.h>
  349. d11 3
  350. a13 3
  351. #include <cxxproto/graphics.h>
  352. #include <cxxproto/intuition.h>
  353. #include <cxxproto/gadtools.h>
  354. d17 3
  355. a19 1
  356. screen::screen(STRPTR name)
  357. d25 12
  358. a36 6
  359.         defpens = new UWORD[NUM_XPENS] ;
  360.         if (defpens) {
  361.             screen = LockPubScreen(name) ;
  362.             if (!screen)
  363.                 screen = LockPubScreen(NULL) ;
  364.             if (screen)
  365. d42 1
  366. a42 1
  367. screen::screen(ULONG tdata, ...)
  368. d49 8
  369. a56 3
  370.         defpens = new UWORD[NUM_XPENS] ;
  371.         if (defpens) {
  372.             screen = OpenScreenTags(NULL,
  373. d60 1
  374. a60 1
  375.             if (screen)
  376. d66 1
  377. a66 1
  378. screen::screen(TagItem *tags)
  379. d72 8
  380. a79 3
  381.         defpens = new UWORD[NUM_XPENS] ;
  382.         if (defpens) {
  383.             screen = OpenScreenTags(NULL,
  384. d83 1
  385. a83 1
  386.             if (screen)
  387. a90 2
  388. int i ;
  389. ColorMap *cm = screen->ViewPort.ColorMap ;
  390. d92 1
  391. a92 1
  392.     vi = GetVisualInfo(screen, TAG_DONE);
  393. d94 1
  394. a94 1
  395.         font = OpenFont(screen->Font) ;
  396. d96 1
  397. a96 1
  398.             drawinfo = GetScreenDrawInfo(screen) ;
  399. d98 1
  400. a98 1
  401.                 rp = &screen->RastPort ;
  402. d100 2
  403. a101 40
  404.                 if (GfxBase->LibNode.lib_Version >= 39) {
  405.  
  406.                     defpens[GREEN_PEN] = ObtainBestPen(cm,
  407.                         0x00000000,
  408.                         0xffffffff,
  409.                         0x00000000,
  410.                         OBP_Precision,  PRECISION_IMAGE,
  411.                         OBP_FailIfBad,  TRUE,
  412.                         TAG_DONE) ;
  413.  
  414.                     defpens[RED_PEN] = ObtainBestPen(cm,
  415.                         0xffffffff,
  416.                         0x00000000,
  417.                         0x00000000,
  418.                         OBP_Precision,  PRECISION_IMAGE,
  419.                         OBP_FailIfBad,  TRUE,
  420.                         TAG_DONE) ;
  421.  
  422.                     defpens[WHITE_PEN] = ObtainBestPen(cm,
  423.                         0xffffffff,
  424.                         0xffffffff,
  425.                         0xffffffff,
  426.                         OBP_Precision,  PRECISION_IMAGE,
  427.                         OBP_FailIfBad,  TRUE,
  428.                         TAG_DONE) ;
  429.  
  430.                     defpens[BLACK_PEN] = ObtainBestPen(cm,
  431.                         0x00000000,
  432.                         0x00000000,
  433.                         0x00000000,
  434.                         OBP_Precision,  PRECISION_IMAGE,
  435.                         OBP_FailIfBad,  TRUE,
  436.                         TAG_DONE) ;
  437.  
  438.                 }
  439.                 else {
  440.                     defpens[GREEN_PEN] = drawinfo->dri_Pens[HIGHLIGHTTEXTPEN] ;
  441.                     defpens[RED_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  442.                     defpens[WHITE_PEN] = drawinfo->dri_Pens[HIGHLIGHTTEXTPEN] ;
  443.                     defpens[BLACK_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  444. a102 38
  445.                 defpens[GFILL_PEN] = drawinfo->dri_Pens[BACKGROUNDPEN] ;
  446.                 defpens[GBORDER_PEN] = drawinfo->dri_Pens[TEXTPEN] ;
  447.                 if (GfxBase->LibNode.lib_Version >= 39) {
  448.                     xpens[GREEN_PEN] =
  449.                         (defpens[GREEN_PEN] != -1) ? defpens[GREEN_PEN] :
  450.                         FindColor(cm,
  451.                             0x00000000,
  452.                             0xffffffff,
  453.                             0x00000000,
  454.                             -1) ;
  455.                     xpens[RED_PEN] =
  456.                         (defpens[RED_PEN] != -1) ? defpens[RED_PEN] :
  457.                         FindColor(cm,
  458.                             0xffffffff,
  459.                             0x00000000,
  460.                             0x00000000,
  461.                             -1) ;
  462.                     xpens[WHITE_PEN] =
  463.                         (defpens[WHITE_PEN] != -1) ? defpens[WHITE_PEN] :
  464.                         FindColor(cm,
  465.                             0xffffffff,
  466.                             0xffffffff,
  467.                             0xffffffff,
  468.                             -1) ;
  469.                     xpens[BLACK_PEN] =
  470.                         (defpens[BLACK_PEN] != -1) ? defpens[BLACK_PEN] :
  471.                         FindColor(cm,
  472.                             0x00000000,
  473.                             0x00000000,
  474.                             0x00000000,
  475.                             -1) ;
  476.                     i = 4 ;
  477.  
  478.                 }
  479.                 else
  480.                     i = 0 ;
  481.                 while (i < NUM_XPENS)
  482.                     xpens[i] = defpens[i++] ;
  483. d122 1
  484. a122 1
  485.             ColorMap *cm = screen->ViewPort.ColorMap ;
  486. d131 1
  487. a131 1
  488.         FreeScreenDrawInfo(screen, drawinfo) ;
  489. d136 1
  490. a136 1
  491.     if (screen) {
  492. d138 1
  493. a138 1
  494.             CloseScreen(screen) ;
  495. d140 1
  496. a140 1
  497.             UnlockPubScreen(NULL, screen) ;
  498. d152 5
  499. a156 5
  500.     left = short(MAX(0, -screen->LeftEdge)) ;
  501.     top = short(MAX(0, -screen->TopEdge) + screen->BarHeight + 1) ;
  502.     height = short(screen->Height - screen->BarHeight) ;
  503.     width = screen->Width ;
  504.     winbarheight = short(screen->WBorTop + font->tf_YSize + 1) ;
  505. d158 1
  506. a158 1
  507.     modeid = GetVPModeID(&screen->ViewPort);
  508. d173 1
  509. a173 1
  510.     ScreenToFront(screen) ;
  511. d178 1
  512. a178 1
  513.     ScreenToBack(screen) ;
  514. d184 1
  515. a184 1
  516.         ScreenDepth(screen, SDEPTH_TOFRONT | SDEPTH_INFAMILY, NULL) ;
  517. d186 1
  518. a186 1
  519.         ScreenToFront(screen) ;
  520. d192 1
  521. a192 1
  522.         ScreenDepth(screen, SDEPTH_TOBACK | SDEPTH_INFAMILY, NULL) ;
  523. d194 1
  524. a194 1
  525.         ScreenToBack(screen) ;
  526. d200 1
  527. a200 1
  528.     DisplayBeep(screen) ;
  529. d207 1
  530. a207 1
  531.     while (p[i] != ~0) {
  532. d211 95
  533. @
  534.